emmm，我或许是有点疯了，不过 Tauri 的 commands 定义还是挺难受了除了这一点还有类型、文档，那么为什么不引入 GraphQL 呢？它具备类型，文档，因所有请求都是同一路径，也能和 Tauri 搭配了，除了依赖 WebSocket 的 Subscription。
下面基于 Juniper 和 SQLx 以及 SQLite 进行实现
#目录结构和上下文
GraphQL 上下文不同于 Tauri 的上下文，Tauri 的上下文一般是全局的，而 GraphQL 的上下文是针对每次连接的。
因此一般在 Tauri 的上下文存储 sqlx 的 pool 和 GraphQL Schema，然后在 GraphQL 的上下文存储 sqlite pool 的克隆，以及一些 repository 和 loader。
整体文件结构目录如下
src-tauri/
├─ commands/
│ ├─ graphql.rs
│ ├─ mod.rs
├─ graphql/
│ ├─ loaders/
│ ├─ relay/
│ ├─ context.rs
│ ├─ mod.rs
│ ├─ scalar.rs
│ ├─ schema.rs
├─ lib.rs
├─ main.rs
├─ state.rs#数据类型映射
SQLite 的 自增 INTEGER ID 在 Rust SQLX 库中用的 i64 表示，我们需要进行转换一下，因为 GraphQL/Juniper 只支持 i32 和 f64，除此之外还有 Timestamp 和 Boolean, 这两个在 SQLite 并没有对应的类型因此均基于 i64 作为原始类型进行包装。
哦，还有一个 Integer ，对于它我们直接把它转为 i32 使用。
为了 Integer 在 SQLx 中方便的转换，我们不能对它进行包装，否则 query_as! 宏无法将 Option<i64> 转换为 Option<Integer>，尽管可以通过 Column Type Override 对目标列修改为特定类型但还是增加繁琐性，SQLx 能否支持如果是 Option 则进行 xxx.map(Into) ?
在 graphql/scalar.rs 文件中编写 Integer 、ID、Timestamp 的代码
#实现 CustomScalarValue
首先编写一个 CustomScalarValue，它是 DefaultScalarValue 的复制，这样做只是为了为 i64 实现自定义的标量。参考 Foreign scalars
DefaultScalarValue 定义在 juniper crate 的 src/value/scalar.rs 文件内，我们将它复制出来然后重命名为 CustomScalarValue
#[derive(Clone, Debug, PartialEq, ScalarValue, Serialize)]
#[serde(untagged)]
pub enum CustomScalarValue {
#[value(as_float, as_int)]
Int(i32),
#[value(as_float)]
Float(f64),
#[value(as_str, as_string, into_string)]
String(String),
#[value(as_bool)]
Boolean(bool),
} #实现 Integer
#[graphql_scalar]
#[graphql(
with = integer_scalar,
parse_token(String),
scalar = CustomScalarValue
)]
pub type Integer = i64;然后为它实现输入输出处理逻辑
mod integer_scalar {
use super::*;
pub(super) fn to_output<S: ScalarValue>(v: &Integer) -> Value<S> {
// 直接强制转为更小的类型
Value::Scalar((*v as i32).into())
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Integer, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `Int`, found: {v}"))
.and_then(|s| match s.parse::<i64>() {
Ok(i) => Ok(i),
Err(e) => Err(format!("{e}")),
})
}
} #实现 Timestamp
#[derive(Debug, Copy, GraphQLScalar, Clone, Eq, PartialEq, Serialize, sqlx::Type)]
#[graphql(
with = timestamp_scalar,
parse_token(String),
)]
pub struct Timestamp(i64);由于 GraphQL 不支持 i64，因此将其转为 rfc3339 字符串形式，这里引入 chrono crate 来处理
mod timestamp_scalar {
use super::*;
use chrono::{DateTime, Utc};
pub(super) fn to_output<S: ScalarValue>(v: &Timestamp) -> Value<S> {
Value::Scalar(
DateTime::<Utc>::from_timestamp(v.0, 0)
.unwrap()
.to_rfc3339()
.into(),
)
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<Timestamp, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `Timestamp`, found {v}"))
.and_then(|s| match DateTime::parse_from_rfc3339(s) {
Ok(dt) => Ok(Timestamp(dt.timestamp())),
Err(e) => Err(format!("{e}")),
})
}
}#实现 ID
#[derive(Debug, Copy, Hash, GraphQLScalar, Clone, Eq, PartialEq, Serialize, sqlx::Type)]
#[graphql(with = id_scalar, parse_token(String))]
pub struct ID(i64);对于 ID 也将其转换 String
mod id_scalar {
use super::*;
pub(super) fn to_output<S: ScalarValue>(v: &ID) -> Value<S> {
let value = base64_url::encode(&v.0.to_be_bytes());
Value::Scalar(value.into())
}
pub(super) fn from_input<S: ScalarValue>(v: &InputValue<S>) -> Result<ID, String> {
v.as_string_value()
.ok_or_else(|| format!("Expected `String`, found: {v}"))
.and_then(|s| {
match base64_url::decode(s)
.map_err(|e| format!("{e}"))
.and_then(|b| b.try_into().map_err(|_e| "Invalid byte length".to_string()))
.map(i64::from_be_bytes)
{
Ok(v) => Ok(ID(v)),
Err(e) => Err(format!("Invalid ID, {e}")),
}
})
}
} #实现 Boolean
突然发现 SQLite 存在 Boolean 类型，该类型没有实现的必要了
#[derive(Debug, Clone, Copy, GraphQLScalar)]
#[graphql(transparent)]
pub struct Boolean(bool);Boolean 主要针对 SQLx 做一些处理，GraphQL 支持 boolean 值，因此标记为 GraphQLScalar 就可以了
impl<'q> Encode<'q, Sqlite> for Boolean {
fn encode_by_ref(
&self,
buf: &mut <Sqlite as Database>::ArgumentBuffer<'q>,
) -> Result<IsNull, BoxDynError> {
<bool as Encode<'q, Sqlite>>::encode_by_ref(&self.0, buf)
}
}
impl<'r> Decode<'r, Sqlite> for Boolean {
fn decode(value: SqliteValueRef<'r>) -> Result<Self, BoxDynError> {
<bool as Decode<'r, Sqlite>>::decode(value).map(Boolean::from)
}
}
impl Type<Sqlite> for Boolean {
fn type_info() -> SqliteTypeInfo {
<i64 as Type<Sqlite>>::type_info()
}
fn compatible(ty: &<Sqlite as Database>::TypeInfo) -> bool {
<i64 as Type<Sqlite>>::compatible(ty)
}
} #创建 graphql 命令入口
在创建命令前我们需要定义 Schema 和 Context 的结构
#创建 GraphQL Schema
首先在 graphql/schema.rs 中创建 schema
pub struct Query;
#[graphql_object]
#[graphql(context = Context, scalar = scalar::CustomScalarValue)]
impl Query{
pub fn greet(name: String) -> String{
format!("Hello, {}! You've been greeted from Rust!", name)
}
}
pub struct Mutation;
#[graphql_object]
#[graphql(context = Context, scalar = scalar::CustomScalarValue)]
impl Mutation {
pub fn add(a: i32, b: i32) -> i32 {
a + b
}
}
pub type Schema =
RootNode<'static, Query, Mutation, EmptySubscription<Context>, scalar::CustomScalarValue>;
pub fn create_schema() -> Schema {
let schema = Schema::new_with_scalar_value(Query, Mutation, EmptySubscription::new());
#[cfg(debug_assertions)]
{
// 每次启动时输出 schema 到文件
let path = ...;
std::fs::write(&path, schema.as_sdl()).unwrap();
}
schema
}#创建 Context
首先在 state.rs 中定义数据库的连接和 GraphQL Schema
SqlitePool 内部使用了 Arc 因此不需要使用 Arc , graphql::Schema 后面只用到其引用，因此也无需使用 Arc
pub struct AppState {
pub pool: SqlitePool,
pub schema: graphql::Schema
}
pub fn build_app_state(pool: SqlitePool) -> AppState{
AppState {
pool,
schema: graphql::create_schema(),
}
}然后在 graphql/context.rs 中定义 GraphQL 的上下文
pub struct Context {
// 这里除了存储数据库连接外还用于存储 service 或 repository
pub pool: SqlitePool
}
impl Context{
pub fn new(pool: SqlitePool) -> Self {
Self { pool }
}
}
impl juniper::Context for Context {}#创建命令
在 commands/graphql.rs 中声明 graphql 命令
#[command]
pub async fn graphql(
state: tauri::State<'_, AppState>,
body: GraphQLRequest<scalar::CustomScalarValue>,
) -> Result<serde_json::Value, serde_json::Value> {
let pool = state.pool.clone();
let context = graphql::Context::new(pool);
let response = body.execute(&state.schema, &context).await;
match (response.is_ok(), serde_json::to_value(response)) {
(true, Ok(v)) => Ok(v),
(false, Ok(v)) => Err(v),
(_, Err(e)) => Err(serde_json::Value::String(e.to_string())),
}
}然后在 lib.rs 中导入使用
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
tauri::Builder::default()
.plugin(tauri_plugin_opener::init())
.invoke_handler(tauri::generate_handler![commands::graphql::graphql])
.run(tauri::generate_context!())
.expect("error while running tauri application");
}至此，便可以在前端以 invoke 形式调用了
import { invoke } from '@tauri-apps/api/core';
const graphql = async <T = unknown>(
query: string,
variables: Record<string, unknown>,
): Promise<T> => {
return invoke("graphql", {
body: {
query,
variables,
},
});
};